package com.zhang.backend.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.zhang.backend.dto.GenealogyNodeDTO;
import com.zhang.backend.entity.Person;
import com.zhang.backend.entity.Relation;
import com.zhang.backend.mapper.PersonMapper;
import com.zhang.backend.mapper.RelationMapper;
import com.zhang.backend.service.GenealogyService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.*;
import java.util.stream.Collectors;

@Service
public class GenealogyServiceImpl implements GenealogyService {

    @Autowired
    private PersonMapper personMapper;

    @Autowired
    private RelationMapper relationMapper;

    // 您代码中已有的其他接口方法，这里省略...
    // public List<FamilyTree> findRootFamilies() { ... }
    // public FamilyTreeNodeDTO buildFullTree(Long rootFamilyId) { ... }

    @Override
    public List<Person> findRootPersons(Long familyTreeId) {
        // 1. 找出该家谱下的所有未被删除的人
        List<Person> allPersonsInTree = personMapper.selectList(
                new QueryWrapper<Person>().eq("family_id", familyTreeId).eq("is_deleted", 0)
        );
        if (allPersonsInTree.isEmpty()) {
            return Collections.emptyList();
        }

        // 2. 找出所有作为“子女”出现的人的ID。
        // 在您“从父到子”的模型中，子女是 person_id2。
        Set<Long> childrenIds = relationMapper.selectList(
                new QueryWrapper<Relation>()
                        .in("relation_type_id", Arrays.asList(7, 8)) // 7:女儿, 8:儿子
                        .eq("is_deleted", 0)
        ).stream().map(Relation::getPersonId2).collect(Collectors.toSet());

        // 3. 根人物就是那些 在这个家谱里，但从未作为“子女”出现过的人。
        return allPersonsInTree.stream()
                .filter(p -> !childrenIds.contains(p.getPersonId()))
                .collect(Collectors.toList());
    }

    @Override
    public GenealogyNodeDTO buildTreeFromRoot(Long rootPersonId) {
        Person rootPerson = personMapper.selectById(rootPersonId);
        if (rootPerson == null) return null;

        // 一次性加载所有关系和人物，避免在递归中频繁查询数据库
        List<Relation> allRelations = relationMapper.selectList(
                new QueryWrapper<Relation>().eq("is_deleted", 0)
        );
        Map<Long, Person> personMap = personMapper.selectList(null).stream()
                .collect(Collectors.toMap(Person::getPersonId, p -> p));

        return buildTreeRecursively(rootPerson, allRelations, personMap);
    }

    /**
     * 【核心修正】重写了构建树的算法，使其匹配“从父到子”的数据模型
     * @param currentPerson 当前节点的人物
     * @param allRelations 所有关系数据
     * @param personMap 所有人物的Map
     * @return 构建好的节点
     */
    private GenealogyNodeDTO buildTreeRecursively(Person currentPerson, List<Relation> allRelations, Map<Long, Person> personMap) {
        GenealogyNodeDTO node = new GenealogyNodeDTO(currentPerson);

        // 查找所有由当前人物发出的关系
        List<Relation> outgoingRelations = allRelations.stream()
                .filter(r -> r.getPersonId1().equals(currentPerson.getPersonId()))
                .collect(Collectors.toList());

        for (Relation rel : outgoingRelations) {
            Person relatedPerson = personMap.get(rel.getPersonId2());
            if (relatedPerson == null) continue;

            // 检查是否是配偶关系 (5:妻子, 6:丈夫, 50:配偶)
            if (Arrays.asList(5, 6, 50).contains(rel.getRelationTypeId())) {
                GenealogyNodeDTO spouseNode = new GenealogyNodeDTO(relatedPerson);
                spouseNode.setName("(配偶) " + relatedPerson.getName());
                // 将配偶作为子节点添加，前端图表会自动处理布局
                node.getChildren().add(spouseNode);
            }
            // 检查是否是子女关系 (7:女儿, 8:儿子)
            else if (Arrays.asList(7, 8).contains(rel.getRelationTypeId())) {
                // 递归地为该子女构建他/她的子树
                node.getChildren().add(buildTreeRecursively(relatedPerson, allRelations, personMap));
            }
        }
        return node;
    }
}
